home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / raiden.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  6KB  |  216 lines
  1.  
  2. #include "driver.h"
  3. #include "vidhrdw/generic.h"
  4.  
  5. static struct tilemap *bg_layer,*fg_layer,*tx_layer;
  6. unsigned char *raiden_back_data,*raiden_fore_data,*raiden_scroll_ram;
  7.  
  8. static int flipscreen,ALTERNATE;
  9.  
  10. /******************************************************************************/
  11.  
  12. READ_HANDLER( raiden_background_r )
  13. {
  14.     return raiden_back_data[offset];
  15. }
  16.  
  17. READ_HANDLER( raiden_foreground_r )
  18. {
  19.     return raiden_fore_data[offset];
  20. }
  21.  
  22. WRITE_HANDLER( raiden_background_w )
  23. {
  24.     raiden_back_data[offset]=data;
  25.     tilemap_mark_tile_dirty( bg_layer,offset/2);
  26. }
  27.  
  28. WRITE_HANDLER( raiden_foreground_w )
  29. {
  30.     raiden_fore_data[offset]=data;
  31.     tilemap_mark_tile_dirty( fg_layer,offset/2);
  32. }
  33.  
  34. WRITE_HANDLER( raiden_text_w )
  35. {
  36.     videoram[offset]=data;
  37.     tilemap_mark_tile_dirty( tx_layer,offset/2);
  38. }
  39.  
  40. WRITE_HANDLER( raidena_text_w )
  41. {
  42.     videoram[offset]=data;
  43.     tilemap_mark_tile_dirty( tx_layer,offset/2);
  44. }
  45.  
  46. static void get_back_tile_info(int tile_index)
  47. {
  48.     int tile=raiden_back_data[2*tile_index]+(raiden_back_data[2*tile_index+1]<<8);
  49.     int color=tile >> 12;
  50.  
  51.     tile=tile&0xfff;
  52.  
  53.     SET_TILE_INFO(1,tile,color)
  54. }
  55.  
  56. static void get_fore_tile_info(int tile_index)
  57. {
  58.     int tile=raiden_fore_data[2*tile_index]+(raiden_fore_data[2*tile_index+1]<<8);
  59.     int color=tile >> 12;
  60.  
  61.     tile=tile&0xfff;
  62.  
  63.     SET_TILE_INFO(2,tile,color)
  64. }
  65.  
  66. static void get_text_tile_info(int tile_index)
  67. {
  68.     int tile=videoram[2*tile_index]+((videoram[2*tile_index+1]&0xc0)<<2);
  69.     int color=videoram[2*tile_index+1]&0xf;
  70.  
  71.     SET_TILE_INFO(0,tile,color)
  72. }
  73.  
  74. static void get_text_alt_tile_info(int tile_index)
  75. {
  76.     int tile=videoram[2*tile_index]+((videoram[2*tile_index+1]&0xc0)<<2);
  77.     int color=videoram[2*tile_index+1]&0xf;
  78.  
  79.     SET_TILE_INFO(0,tile,color)
  80. }
  81.  
  82. int raiden_vh_start(void)
  83. {
  84.     bg_layer = tilemap_create(get_back_tile_info,tilemap_scan_cols,TILEMAP_OPAQUE,     16,16,32,32);
  85.     fg_layer = tilemap_create(get_fore_tile_info,tilemap_scan_cols,TILEMAP_TRANSPARENT,16,16,32,32);
  86.  
  87.     /* Weird - Raiden (Alternate) has different char format! */
  88.     if (!strcmp(Machine->gamedrv->name,"raiden"))
  89.         ALTERNATE=0;
  90.     else
  91.         ALTERNATE=1;
  92.  
  93.     /* Weird - Raiden (Alternate) has different char format! */
  94.     if (!ALTERNATE)
  95.         tx_layer = tilemap_create(get_text_tile_info,tilemap_scan_cols,TILEMAP_TRANSPARENT,8,8,32,32);
  96.     else
  97.         tx_layer = tilemap_create(get_text_alt_tile_info,tilemap_scan_cols,TILEMAP_TRANSPARENT,8,8,32,32);
  98.  
  99.     if (!bg_layer || !fg_layer || !tx_layer)
  100.         return 1;
  101.  
  102.     fg_layer->transparent_pen = 15;
  103.     tx_layer->transparent_pen = 15;
  104.  
  105.     return 0;
  106. }
  107.  
  108. WRITE_HANDLER( raiden_control_w )
  109. {
  110.     /* All other bits unknown - could be playfield enables */
  111.  
  112.     /* Flipscreen */
  113.     if (offset==6) {
  114.         flipscreen=data&0x2;
  115.         tilemap_set_flip(ALL_TILEMAPS,flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  116.     }
  117. }
  118.  
  119. static void draw_sprites(struct osd_bitmap *bitmap,int pri_mask)
  120. {
  121.     int offs,fx,fy,x,y,color,sprite;
  122.  
  123.     for (offs = 0x1000-8;offs >= 0;offs -= 8)
  124.     {
  125.         /* Don't draw empty sprite table entries */
  126.         if (buffered_spriteram[offs+7]!=0xf) continue;
  127.         if (buffered_spriteram[offs+0]==0xf0f) continue;
  128.         if (!(pri_mask&buffered_spriteram[offs+5])) continue;
  129.  
  130.         fx= buffered_spriteram[offs+1]&0x20;
  131.         fy= buffered_spriteram[offs+1]&0x40;
  132.         y = buffered_spriteram[offs+0];
  133.         x = buffered_spriteram[offs+4];
  134.  
  135.         if (buffered_spriteram[offs+5]&1) x=0-(0x100-x);
  136.  
  137.         color = buffered_spriteram[offs+1]&0xf;
  138.         sprite = buffered_spriteram[offs+2]+(buffered_spriteram[offs+3]<<8);
  139.         sprite &= 0x0fff;
  140.  
  141.         if (flipscreen) {
  142.             x=240-x;
  143.             y=240-y;
  144.             if (fx) fx=0; else fx=1;
  145.             if (fy) fy=0; else fy=1;
  146.         }
  147.  
  148.         drawgfx(bitmap,Machine->gfx[3],
  149.                 sprite,
  150.                 color,fx,fy,x,y,
  151.                 &Machine->drv->visible_area,TRANSPARENCY_PEN,15);
  152.     }
  153. }
  154.  
  155. void raiden_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  156. {
  157.     int color,offs,sprite;
  158.     int colmask[16],i,pal_base;
  159.  
  160.     /* Setup the tilemaps, alternate version has different scroll positions */
  161.     if (!ALTERNATE) {
  162.         tilemap_set_scrollx( bg_layer,0, ((raiden_scroll_ram[1]<<8)+raiden_scroll_ram[0]) );
  163.         tilemap_set_scrolly( bg_layer,0, ((raiden_scroll_ram[3]<<8)+raiden_scroll_ram[2]) );
  164.         tilemap_set_scrollx( fg_layer,0, ((raiden_scroll_ram[5]<<8)+raiden_scroll_ram[4]) );
  165.         tilemap_set_scrolly( fg_layer,0, ((raiden_scroll_ram[7]<<8)+raiden_scroll_ram[6]) );
  166.     }
  167.     else {
  168.         tilemap_set_scrolly( bg_layer,0, ((raiden_scroll_ram[0x02]&0x30)<<4)+((raiden_scroll_ram[0x04]&0x7f)<<1)+((raiden_scroll_ram[0x04]&0x80)>>7) );
  169.         tilemap_set_scrollx( bg_layer,0, ((raiden_scroll_ram[0x12]&0x30)<<4)+((raiden_scroll_ram[0x14]&0x7f)<<1)+((raiden_scroll_ram[0x14]&0x80)>>7) );
  170.         tilemap_set_scrolly( fg_layer,0, ((raiden_scroll_ram[0x22]&0x30)<<4)+((raiden_scroll_ram[0x24]&0x7f)<<1)+((raiden_scroll_ram[0x24]&0x80)>>7) );
  171.         tilemap_set_scrollx( fg_layer,0, ((raiden_scroll_ram[0x32]&0x30)<<4)+((raiden_scroll_ram[0x34]&0x7f)<<1)+((raiden_scroll_ram[0x34]&0x80)>>7) );
  172.     }
  173.  
  174.     tilemap_update(ALL_TILEMAPS);
  175.  
  176.     /* Build the dynamic palette */
  177.     palette_init_used_colors();
  178.  
  179.     /* Sprites */
  180.     pal_base = Machine->drv->gfxdecodeinfo[3].color_codes_start;
  181.     for (color = 0;color < 16;color++) colmask[color] = 0;
  182.     for (offs = 0;offs <0x1000;offs += 8)
  183.     {
  184.         color = buffered_spriteram[offs+1]&0xf;
  185.         sprite = buffered_spriteram[offs+2]+(buffered_spriteram[offs+3]<<8);
  186.         sprite &= 0x0fff;
  187.         colmask[color] |= Machine->gfx[3]->pen_usage[sprite];
  188.     }
  189.     for (color = 0;color < 16;color++)
  190.     {
  191.         for (i = 0;i < 15;i++)
  192.         {
  193.             if (colmask[color] & (1 << i))
  194.                 palette_used_colors[pal_base + 16 * color + i] = PALETTE_COLOR_USED;
  195.         }
  196.     }
  197.  
  198.     if (palette_recalc())
  199.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  200.  
  201.     tilemap_render(ALL_TILEMAPS);
  202.     tilemap_draw(bitmap,bg_layer,0);
  203.  
  204.     /* Draw sprites underneath foreground */
  205.     draw_sprites(bitmap,0x40);
  206.     tilemap_draw(bitmap,fg_layer,0);
  207.  
  208.     /* Rest of sprites */
  209.     draw_sprites(bitmap,0x80);
  210.  
  211.     /* Text layer */
  212.     tilemap_draw(bitmap,tx_layer,0);
  213. }
  214.  
  215.  
  216.